#ifndef GPS_TYPES_H
#define GPS_TYPES_H

#include "StringTable.h"
namespace gpstxt
{


	enum TagType
	{
		TT_IGNORE ,         // this tag should be completely ignored.
		TT_BOOL ,           // this tag is a boolean
		TT_INT ,             // this tag is an integer.
		TT_INT_PAIR ,       // used to the census
		TT_FLOAT ,          // This tag is a floating point number.
		TT_STRING ,         // This tag is a retained string.
		TT_DIRECTION,       //Contains directions like N/S/E/W
		TT_ENUM,            //Enumerated types
		TT_MULTI_ENUM,      //Multiple Enumerated types
		TT_NAME_TYPE,       //Is a name type field
		TT_ZIP,             //Series of zip code
		TT_MULTI_DIRECTION  //multiple direction prefix/suffix tags
	};

//*****************************************************************
enum ElementType {
	ET_NONE,		//[0] NONE
	ET_ND,		//[1] nd
	ET_TAG,		//[2] tag
	ET_NODE,		//[3] node
	ET_WAY,		//[4] way
	ET_MEMBER,		//[5] member
	ET_RELATION,		//[6] relation
	ET_BOUNDS,		//[7] bounds
	ET_OSM,		//[8] osm
	ET_XML,		//[9] xml
	ET_LAST
};

void initElementType(StringTableInt &types);
//*****************************************************************

//*****************************************************************
enum AttributeType {
	AT_NONE,		//[0] NONE
	AT_VERSION,		//[1] version
	AT_CHANGESET,		//[2] changeset
	AT_ID,		//[3] id
	AT_TIMESTAMP,		//[4] timestamp
	AT_UID,		//[5] uid
	AT_USER,		//[6] user
	AT_LAT,		//[7] lat
	AT_LON,		//[8] lon
	AT_GENERATOR,		//[9] generator
	AT_MAXLAT,		//[10] maxlat
	AT_MAXLON,		//[11] maxlon
	AT_MINLAT,		//[12] minlat
	AT_MINLON,		//[13] minlon
	AT_ORIGIN,		//[14] origin
	AT_K,		//[15] k
	AT_REF,		//[16] ref
	AT_ROLE,		//[17] role
	AT_TYPE,		//[18] type
	AT_V,		//[19] v
	AT_LAST
};

void initAttributeType(StringTableInt &types);
//*****************************************************************

//*****************************************************************
enum WayTagType {
	WTT_NONE,		//[0] NONE
	WTT_HIGHWAY,		//[1] highway
	WTT_COUNTY,		//[2] county
	WTT_NAME,		//[3] name
	WTT_SEPARATED,		//[4] separated
	WTT_NAME__BASE,		//[5] name_base
	WTT_NAME__TYPE,		//[6] name_type
	WTT_ZIP__LEFT,		//[7] zip_left
	WTT_ZIP__RIGHT,		//[8] zip_right
	WTT_ELE,		//[9] ele
	WTT_ONEWAY,		//[10] oneway
	WTT_NAME__DIRECTION__PREFIX,		//[11] name_direction_prefix
	WTT_ACCESS,		//[12] access
	WTT_WATERWAY,		//[13] waterway
	WTT_NAME__BASE__1,		//[14] name_base_1
	WTT_AMENITY,		//[15] amenity
	WTT_NAME__1,		//[16] name_1
	WTT_ATTRIBUTION,		//[17] attribution
	WTT_NATURAL,		//[18] natural
	WTT_POWER,		//[19] power
	WTT_BUILDING,		//[20] building
	WTT_SERVICE,		//[21] service
	WTT_RAILWAY,		//[22] railway
	WTT_NAME__TYPE__1,		//[23] name_type_1
	WTT_IS__IN,		//[24] is_in
	WTT_LANES,		//[25] lanes
	WTT_SURFACE,		//[26] surface
	WTT_ADDR,		//[27] addr
	WTT_BOUNDARY,		//[28] boundary
	WTT_ZIP__LEFT__1,		//[29] zip_left_1
	WTT_BRIDGE,		//[30] bridge
	WTT_LAYER,		//[31] layer
	WTT_RELIGION,		//[32] religion
	WTT_ADMIN__LEVEL,		//[33] admin_level
	WTT_HGV,		//[34] hgv
	WTT_SIDEWALK,		//[35] sidewalk
	WTT_PLACE,		//[36] place
	WTT_OPERATOR,		//[37] operator
	WTT_LANDUSE,		//[38] landuse
	WTT_ZIP__RIGHT__1,		//[39] zip_right_1
	WTT_LEISURE,		//[40] leisure
	WTT_ELECTRIFIED,		//[41] electrified
	WTT_BICYCLE,		//[42] bicycle
	WTT_GAUGE,		//[43] gauge
	WTT_DENOMINATION,		//[44] denomination
	WTT_MAXSPEED,		//[45] maxspeed
	WTT_FOOT,		//[46] foot
	WTT_OLD__RAILWAY__OPERATOR,		//[47] old_railway_operator
	WTT_TYPE,		//[48] type
	WTT_FREQUENCY,		//[49] frequency
	WTT_VOLTAGE,		//[50] voltage
	WTT_ZIP__LEFT__2,		//[51] zip_left_2
	WTT_HORSE,		//[52] horse
	WTT_WIKIPEDIA,		//[53] wikipedia
	WTT_NOTE,		//[54] note
	WTT_NAME__BASE__2,		//[55] name_base_2
	WTT_EXIT__TO,		//[56] exit_to
	WTT_MOTOR__VEHICLE,		//[57] motor_vehicle
	WTT_AEROWAY,		//[58] aeroway
	WTT_NAME__DIRECTION__SUFFIX,		//[59] name_direction_suffix
	WTT_BORDER__TYPE,		//[60] border_type
	WTT_SPORT,		//[61] sport
	WTT_NAME__DIRECTION__SUFFIX__1,		//[62] name_direction_suffix_1
	WTT_NAME__DIRECTION__PREFIX__1,		//[63] name_direction_prefix_1
	WTT_NAME__2,		//[64] name_2
	WTT_CPI,		//[65] cpi
	WTT_FUNCSTAT,		//[66] funcstat
	WTT_LSAD,		//[67] lsad
	WTT_NAMELSAD,		//[68] namelsad
	WTT_PCICBSA,		//[69] pcicbsa
	WTT_PCINECTA,		//[70] pcinecta
	WTT_PLACEFP,		//[71] placefp
	WTT_PLACENS,		//[72] placens
	WTT_PLCIDFP,		//[73] plcidfp
	WTT_STATEFP,		//[74] statefp
	WTT_WEBSITE,		//[75] website
	WTT_CYCLEWAY,		//[76] cycleway
	WTT_POPULATION,		//[77] population
	WTT_CENSUS,		//[78] census
	WTT_ZIP__RIGHT__2,		//[79] zip_right_2
	WTT_BARRIER,		//[80] barrier
	WTT_SHOP,		//[81] shop
	WTT_NHS,		//[82] nhs
	WTT_MAN__MADE,		//[83] man_made
	WTT_ROUTE,		//[84] route
	WTT_NAME__TYPE__2,		//[85] name_type_2
	WTT_CABLES,		//[86] cables
	WTT_NCN__REF,		//[87] ncn_ref
	WTT_ZIP__LEFT__3,		//[88] zip_left_3
	WTT_TUNNEL,		//[89] tunnel
	WTT_OLD__REF,		//[90] old_ref
	WTT_SOCIAL__NETWORK,		//[91] social_network
	WTT_JUNCTION,		//[92] junction
	WTT_NETWORK,		//[93] network
	WTT_GOLF,		//[94] golf
	WTT_CUISINE,		//[95] cuisine
	WTT_LIT,		//[96] lit
	WTT_TOURISM,		//[97] tourism
	WTT_PARKING,		//[98] parking
	WTT_SOURCE__REF,		//[99] source_ref
	WTT_CONSTRUCTION,		//[100] construction
	WTT_ZIP__RIGHT__3,		//[101] zip_right_3
	WTT_BOAT,		//[102] boat
	WTT_SHIP,		//[103] ship
	WTT_DEEP__DRAFT,		//[104] deep_draft
	WTT_NAME__DIRECTION__SUFFIX__2,		//[105] name_direction_suffix_2
	WTT_SEGREGATED,		//[106] segregated
	WTT_PHONE,		//[107] phone
	WTT_NIST,		//[108] nist
	WTT_ZIP__LEFT__4,		//[109] zip_left_4
	WTT_SYMBOL,		//[110] symbol
	WTT_NAME__BASE__3,		//[111] name_base_3
	WTT_CAPACITY,		//[112] capacity
	WTT_DESIGNATION,		//[113] designation
	WTT_NOREF,		//[114] noref
	WTT_LCN,		//[115] lcn
	WTT_HISTORIC,		//[116] historic
	WTT_AREA,		//[117] area
	WTT_FUT__REF,		//[118] fut_ref
	WTT_GOLF__CART,		//[119] golf_cart
	WTT_ALT__NAME,		//[120] alt_name
	WTT_ZIP__RIGHT__4,		//[121] zip_right_4
	WTT_FROM,		//[122] from
	WTT_MOWN,		//[123] mown
	WTT_NAME__DIRECTION__PREFIX__2,		//[124] name_direction_prefix_2
	WTT_TO,		//[125] to
	WTT_FINELY__MOWN,		//[126] finely_mown
	WTT_NAME__3,		//[127] name_3
	WTT_NAME__TYPE__3,		//[128] name_type_3
	WTT_NOEXIT,		//[129] noexit
	WTT_VOLTAGE_HIGH,		//[130] voltage-high
	WTT_FEE,		//[131] fee
	WTT_ATTRACTION,		//[132] attraction
	WTT_ODBL,		//[133] odbl
	WTT_COURTS,		//[134] courts
	WTT_RESTRICTION,		//[135] restriction
	WTT_OLD__NAME,		//[136] old_name
	WTT_VIA,		//[137] via
	WTT_BRAND,		//[138] brand
	WTT_MOTORCAR,		//[139] motorcar
	WTT_EMERGENCY,		//[140] emergency
	WTT_EXPRESSWAY,		//[141] expressway
	WTT_CROSSING,		//[142] crossing
	WTT_URL,		//[143] url
	WTT_GENERATOR,		//[144] generator
	WTT_NFD,		//[145] nfd
	WTT_REG__NAME,		//[146] reg_name
	WTT_BACKREST,		//[147] backrest
	WTT_MODIFIER,		//[148] modifier
	WTT_NAME__DIRECTION__SUFFIX__3,		//[149] name_direction_suffix_3
	WTT_PROPOSED,		//[150] proposed
	WTT_SHELTER,		//[151] shelter
	WTT_STATE,		//[152] state
	WTT_FUEL,		//[153] fuel
	WTT_IS_P_IN,		//[154] is)in
	WTT_ROUTE__MASTER,		//[155] route_master
	WTT_SHELTER__TYPE,		//[156] shelter_type
	WTT_DESCRIPTION,		//[157] description
	WTT_LOC__NAME,		//[158] loc_name
	WTT_NAME__DIRECTION__PREFIX__3,		//[159] name_direction_prefix_3
	WTT_NAT__NAME,		//[160] nat_name
	WTT_PSV,		//[161] psv
	WTT_SITE__TYPE,		//[162] site_type
	WTT_WIFI,		//[163] wifi
	WTT_ATM,		//[164] atm
	WTT_COVERED,		//[165] covered
	WTT_DESTINATION,		//[166] destination
	WTT_DIRECTION,		//[167] direction
	WTT_LOCK,		//[168] lock
	WTT_OPENING__HOURS,		//[169] opening_hours
	WTT_VOLTAGE_LOW,		//[170] voltage-low
	WTT_ARCHITECT,		//[171] architect
	WTT_ARTWORK,		//[172] artwork
	WTT_BUSINESS,		//[173] business
	WTT_DISPENSING,		//[174] dispensing
	WTT_EMBANKMENT,		//[175] embankment
	WTT_HIGHWY,		//[176] highwy
	WTT_IATA,		//[177] iata
	WTT_MAXWEIGHT,		//[178] maxweight
	WTT_PAVED,		//[179] paved
	WTT_RECYCLING,		//[180] recycling
	WTT_TRAFFIC__CALMING,		//[181] traffic_calming
	WTT_WHEELCHAIR,		//[182] wheelchair
	WTT_ANIMAL,		//[183] animal
	WTT_AUTOMATED,		//[184] automated
	WTT_CONTACT,		//[185] contact
	WTT_FAA,		//[186] faa
	WTT_HIGHWAY2,		//[187] highway2
	WTT_INDOOR,		//[188] indoor
	WTT_MAXSTAY,		//[189] maxstay
	WTT_MOTORCYCLE,		//[190] motorcycle
	WTT_NAME2,		//[191] name2
	WTT_NAME__4,		//[192] name_4
	WTT_NAME__BASE__4,		//[193] name_base_4
	WTT_SCENIC,		//[194] scenic
	WTT_SELF__SERVICE,		//[195] self_service
	WTT_SMOKING,		//[196] smoking
	WTT_SPECIES,		//[197] species
	WTT_TIMEZONE,		//[198] timezone
	WTT_TOLL,		//[199] toll
	WTT_TOWER,		//[200] tower
	WTT_UNSIGNED__REF,		//[201] unsigned_ref
	WTT_WIDTH,		//[202] width
	WTT_AD,		//[203] ad
	WTT_BANE,		//[204] bane
	WTT_BOARD__TYPE,		//[205] board_type
	WTT_CLOSEST__TOWN,		//[206] closest_town
	WTT_COMMENT,		//[207] comment
	WTT_CUTTING,		//[208] cutting
	WTT_DENOTATION,		//[209] denotation
	WTT_DISTANCE,		//[210] distance
	WTT_DRINKABLE,		//[211] drinkable
	WTT_EMAIL,		//[212] email
	WTT_FAX,		//[213] fax
	WTT_FISHING,		//[214] fishing
	WTT_FOUNDER,		//[215] founder
	WTT_GRADES,		//[216] grades
	WTT_HEIGHT,		//[217] height
	WTT_INDUSTRIAL,		//[218] industrial
	WTT_INFORMATION,		//[219] information
	WTT_ISO3166_1,		//[220] iso3166-1
	WTT_LAND__USE,		//[221] land_use
	WTT_LEVEL,		//[222] level
	WTT_LOCAL__REF,		//[223] local_ref
	WTT_MARITIME,		//[224] maritime
	WTT_MILITARY,		//[225] military
	WTT_MONITORING__STATION,		//[226] monitoring_station
	WTT_NAME__OLD,		//[227] name_old
	WTT_NCN,		//[228] ncn
	WTT_NONAME,		//[229] noname
	WTT_OFFICE,		//[230] office
	WTT_OWNER,		//[231] owner
	WTT_PARK,		//[232] park
	WTT_PARK__RIDE,		//[233] park_ride
	WTT_PARK__SIZE,		//[234] park_size
	WTT_POINT_OF_INTEREST,		//[235] point of interest
	WTT_POSTAL__CODE,		//[236] postal_code
	WTT_PRODUCT,		//[237] product
	WTT_RADAR,		//[238] radar
	WTT_SAC__SCALE,		//[239] sac_scale
	WTT_SEASONAL,		//[240] seasonal
	WTT_SEATS,		//[241] seats
	WTT_SERVICE_ACCESS,		//[242] service access
	WTT_SIGN,		//[243] sign
	WTT_SOUREC,		//[244] sourec
	WTT_START__DATE,		//[245] start_date
	WTT_SYM,		//[246] sym
	WTT_TRAIL__VISIBILITY,		//[247] trail_visibility
	WTT_USAGE,		//[248] usage
	WTT_ZIP__RIGHT__14,		//[249] zip_right_14
	WTT_CFCC,		//[250] cfcc
	WTT_CLASSFP,		//[251] classfp
	WTT_COLOR,		//[252] color
	WTT_CREATED__BY,		//[253] created_by
	WTT_EDITED__BY,		//[254] edited_by
	WTT_FIXME,		//[255] fixme
	WTT_GNIS,		//[256] gnis
	WTT_HISTORY,		//[257] history
	WTT_ICAO,		//[258] icao
	WTT_IMPORT__UUID,		//[259] import_uuid
	WTT_MTFCC,		//[260] mtfcc
	WTT_NHD,		//[261] nhd
	WTT_REF,		//[262] ref
	WTT_REVIEWED,		//[263] reviewed
	WTT_SOURCE,		//[264] source
	WTT_TIME,		//[265] time
	WTT_TLID,		//[266] tlid
	WTT_UPDATED__BY,		//[267] updated_by
	WTT_UPLOAD__UUID,		//[268] upload_uuid
	WTT_LAST
};

void initWayTagType(StringTableInt &types);
//*****************************************************************

//*****************************************************************
enum SubKeyType {
	SKT_NONE,		//[0] NONE
	SKT_FTYPE,		//[1] ftype
	SKT_COMID,		//[2] comid
	SKT_FCODE,		//[3] fcode
	SKT_RESOLUTION,		//[4] resolution
	SKT_REACHCODE,		//[5] reachcode
	SKT_FEATURE__ID,		//[6] feature_id
	SKT_CREATED,		//[7] created
	SKT_COUNTY__ID,		//[8] county_id
	SKT_STATE__ID,		//[9] state_id
	SKT_WAY__ID,		//[10] way_id
	SKT_FDATE,		//[11] fdate
	SKT_PERMANENT__,		//[12] permanent_
	SKT_STATE,		//[13] state
	SKT_ID,		//[14] id
	SKT_CLASS,		//[15] class
	SKT_COUNTY,		//[16] county
	SKT_COUNTY__NUM,		//[17] county_num
	SKT_ST__ALPHA,		//[18] st_alpha
	SKT_ST__NUM,		//[19] st_num
	SKT_POSTCODE,		//[20] postcode
	SKT_COUNTY__NAME,		//[21] county_name
	SKT_IMPORT__UUID,		//[22] import_uuid
	SKT_REVIEWED,		//[23] reviewed
	SKT_COUNTRY,		//[24] country
	SKT_HOUSENUMBER,		//[25] housenumber
	SKT_COUNTRY__CODE,		//[26] country_code
	SKT_ISO__3166__2,		//[27] iso_3166_2
	SKT_STATE__CODE,		//[28] state_code
	SKT_STREET,		//[29] street
	SKT_OLD__RAILWAY__OPERATOR,		//[30] old_railway_operator
	SKT_POPULATION,		//[31] population
	SKT_FEATURE__TYPE,		//[32] feature_type
	SKT_EN,		//[33] en
	SKT_ELEVATION,		//[34] elevation
	SKT_CITY,		//[35] city
	SKT_HGV_NATIONAL__NETWORK,		//[36] hgv:national_network
	SKT_NATIONAL__NETWORK,		//[37] national_network
	SKT_GNIS__ID,		//[38] gnis_id
	SKT_GNIS__NAME,		//[39] gnis_name
	SKT_DEEP__DRAFT,		//[40] deep_draft
	SKT_NAME,		//[41] name
	SKT_TWITTER,		//[42] twitter
	SKT_FACEBOOK,		//[43] facebook
	SKT_FLOW,		//[44] flow
	SKT_FULL,		//[45] full
	SKT_FIPS__CODE,		//[46] fips_code
	SKT_STATE__FIPS,		//[47] state_fips
	SKT_EDITED,		//[48] edited
	SKT_HOUSENAME,		//[49] housename
	SKT_YOUTUBE,		//[50] youtube
	SKT_LANES,		//[51] lanes
	SKT_MYSPACE,		//[52] myspace
	SKT_RELATED,		//[53] related
	SKT_RIGHT,		//[54] right
	SKT_FLICKR,		//[55] flickr
	SKT_USE,		//[56] use
	SKT_COLOR,		//[57] color
	SKT_RU,		//[58] ru
	SKT_DISABLED,		//[59] disabled
	SKT_INTERPOLATION,		//[60] interpolation
	SKT_LEFT,		//[61] left
	SKT_TWITTER2,		//[62] twitter2
	SKT_AR,		//[63] ar
	SKT_ARC,		//[64] arc
	SKT_BG,		//[65] bg
	SKT_EL,		//[66] el
	SKT_EO,		//[67] eo
	SKT_FA,		//[68] fa
	SKT_FACEBOOK2,		//[69] facebook2
	SKT_HAW,		//[70] haw
	SKT_HE,		//[71] he
	SKT_HY,		//[72] hy
	SKT_JA,		//[73] ja
	SKT_KA,		//[74] ka
	SKT_LT,		//[75] lt
	SKT_LV,		//[76] lv
	SKT_NV,		//[77] nv
	SKT_OUTPUT_ELECTRICITY,		//[78] output:electricity
	SKT_SOURCE,		//[79] source
	SKT_SR,		//[80] sr
	SKT_SV,		//[81] sv
	SKT_TH,		//[82] th
	SKT_TYPE,		//[83] type
	SKT_UK,		//[84] uk
	SKT_YI,		//[85] yi
	SKT_AMENITY,		//[86] amenity
	SKT_AZ,		//[87] az
	SKT_BRANCH,		//[88] branch
	SKT_DIESEL,		//[89] diesel
	SKT_ES,		//[90] es
	SKT_EU,		//[91] eu
	SKT_GL,		//[92] gl
	SKT_HAK,		//[93] hak
	SKT_HI,		//[94] hi
	SKT_HT,		//[95] ht
	SKT_KO,		//[96] ko
	SKT_LA,		//[97] la
	SKT_METHOD,		//[98] method
	SKT_MG,		//[99] mg
	SKT_ML,		//[100] ml
	SKT_MN,		//[101] mn
	SKT_OC,		//[102] oc
	SKT_ONEWAY,		//[103] oneway
	SKT_QU,		//[104] qu
	SKT_REF,		//[105] ref
	SKT_SL,		//[106] sl
	SKT_SQ,		//[107] sq
	SKT_TA,		//[108] ta
	SKT_TL,		//[109] tl
	SKT_UR,		//[110] ur
	SKT_UZ,		//[111] uz
	SKT_ZH,		//[112] zh
	SKT_ACE,		//[113] ace
	SKT_AF,		//[114] af
	SKT_ALS,		//[115] als
	SKT_ALUMINIUM,		//[116] aluminium
	SKT_AM,		//[117] am
	SKT_AN,		//[118] an
	SKT_ANG,		//[119] ang
	SKT_AS,		//[120] as
	SKT_AST,		//[121] ast
	SKT_BA,		//[122] ba
	SKT_BAKERY,		//[123] bakery
	SKT_BAR,		//[124] bar
	SKT_BE,		//[125] be
	SKT_BIODIESEL,		//[126] biodiesel
	SKT_BIOGAS,		//[127] biogas
	SKT_BN,		//[128] bn
	SKT_BR,		//[129] br
	SKT_BS,		//[130] bs
	SKT_CA,		//[131] ca
	SKT_CANS,		//[132] cans
	SKT_CDO,		//[133] cdo
	SKT_CE,		//[134] ce
	SKT_CEB,		//[135] ceb
	SKT_CKB,		//[136] ckb
	SKT_CO,		//[137] co
	SKT_CONTINENT,		//[138] continent
	SKT_CRH,		//[139] crh
	SKT_CS,		//[140] cs
	SKT_CU,		//[141] cu
	SKT_CV,		//[142] cv
	SKT_CY,		//[143] cy
	SKT_DA,		//[144] da
	SKT_DE,		//[145] de
	SKT_DELI,		//[146] deli
	SKT_DIQ,		//[147] diq
	SKT_DSB,		//[148] dsb
	SKT_E10,		//[149] e10
	SKT_ELECTRICITY,		//[150] electricity
	SKT_ET,		//[151] et
	SKT_EXT,		//[152] ext
	SKT_FI,		//[153] fi
	SKT_FIU_VRO,		//[154] fiu-vro
	SKT_FLORIST,		//[155] florist
	SKT_FO,		//[156] fo
	SKT_FR,		//[157] fr
	SKT_FRP,		//[158] frp
	SKT_FUR,		//[159] fur
	SKT_FY,		//[160] fy
	SKT_GA,		//[161] ga
	SKT_GD,		//[162] gd
	SKT_GN,		//[163] gn
	SKT_GU,		//[164] gu
	SKT_GV,		//[165] gv
	SKT_HA,		//[166] ha
	SKT_HR,		//[167] hr
	SKT_HSB,		//[168] hsb
	SKT_HU,		//[169] hu
	SKT_IA,		//[170] ia
	SKT_IE,		//[171] ie
	SKT_ILO,		//[172] ilo
	SKT_IO,		//[173] io
	SKT_IS,		//[174] is
	SKT_IT,		//[175] it
	SKT_IU,		//[176] iu
	SKT_JV,		//[177] jv
	SKT_KK,		//[178] kk
	SKT_KL,		//[179] kl
	SKT_KN,		//[180] kn
	SKT_KS,		//[181] ks
	SKT_KU,		//[182] ku
	SKT_KV,		//[183] kv
	SKT_KW,		//[184] kw
	SKT_KY,		//[185] ky
	SKT_LAD,		//[186] lad
	SKT_LB,		//[187] lb
	SKT_LEVELS,		//[188] levels
	SKT_LI,		//[189] li
	SKT_LIJ,		//[190] lij
	SKT_LMO,		//[191] lmo
	SKT_LN,		//[192] ln
	SKT_MAN__MADE,		//[193] man_made
	SKT_MDF,		//[194] mdf
	SKT_MEAT,		//[195] meat
	SKT_MHR,		//[196] mhr
	SKT_MI,		//[197] mi
	SKT_MK,		//[198] mk
	SKT_MR,		//[199] mr
	SKT_MS,		//[200] ms
	SKT_MT,		//[201] mt
	SKT_MWL,		//[202] mwl
	SKT_NAH,		//[203] nah
	SKT_NAP,		//[204] nap
	SKT_NDS,		//[205] nds
	SKT_NE,		//[206] ne
	SKT_NL,		//[207] nl
	SKT_NO,		//[208] no
	SKT_NOV,		//[209] nov
	SKT_NRM,		//[210] nrm
	SKT_OTHER,		//[211] other
	SKT_PA,		//[212] pa
	SKT_PAM,		//[213] pam
	SKT_PDC,		//[214] pdc
	SKT_PHARMACY,		//[215] pharmacy
	SKT_PKEY,		//[216] pkey
	SKT_PL,		//[217] pl
	SKT_PMS,		//[218] pms
	SKT_PS,		//[219] ps
	SKT_PT,		//[220] pt
	SKT_RELATED2,		//[221] related2
	SKT_RM,		//[222] rm
	SKT_RN,		//[223] rn
	SKT_RO,		//[224] ro
	SKT_SA,		//[225] sa
	SKT_SAH,		//[226] sah
	SKT_SC,		//[227] sc
	SKT_SCO,		//[228] sco
	SKT_SCRAP__METAL,		//[229] scrap_metal
	SKT_SE,		//[230] se
	SKT_SEAFOOD,		//[231] seafood
	SKT_SH,		//[232] sh
	SKT_SI,		//[233] si
	SKT_SIGNS,		//[234] signs
	SKT_SINGLE,		//[235] single
	SKT_SK,		//[236] sk
	SKT_SM,		//[237] sm
	SKT_STQ,		//[238] stq
	SKT_SU,		//[239] su
	SKT_SW,		//[240] sw
	SKT_SZL,		//[241] szl
	SKT_TE,		//[242] te
	SKT_TET,		//[243] tet
	SKT_TG,		//[244] tg
	SKT_TO,		//[245] to
	SKT_TPI,		//[246] tpi
	SKT_TR,		//[247] tr
	SKT_TT,		//[248] tt
	SKT_TWITTER3,		//[249] twitter3
	SKT_UG,		//[250] ug
	SKT_VEC,		//[251] vec
	SKT_VI,		//[252] vi
	SKT_VLS,		//[253] vls
	SKT_WA,		//[254] wa
	SKT_WO,		//[255] wo
	SKT_WUU,		//[256] wuu
	SKT_XAL,		//[257] xal
	SKT_XH,		//[258] xh
	SKT_ZH_CLASSICAL,		//[259] zh-classical
	SKT_ZH_MIN_NAN,		//[260] zh-min-nan
	SKT_ZH_YUE,		//[261] zh-yue
	SKT_LAST
};

void initSubKeyType(StringTableInt &types);
//*****************************************************************

//*****************************************************************
// Enumeration Definition for 'Ncn'
//*****************************************************************
struct Ncn {
	enum {
		_NONE,		//[0] NONE
		PROPOSED,		//[0]
		LAST
	};
};

void initNcn(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Sourec'
//*****************************************************************
struct Sourec {
	enum {
		_NONE,		//[0] NONE
		BING,		//[0]
		LAST
	};
};

void initSourec(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Separated'
//*****************************************************************
struct Separated {
	enum {
		_NONE,		//[0] NONE
		N,		//[0]
		NO,		//[1]
		NO_YES,		//[2]
		YES,		//[3]
		LAST
	};
};

void initSeparated(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Service'
//*****************************************************************
struct Service {
	enum {
		_NONE,		//[0] NONE
		ALLEY,		//[0]
		DRIVE_THROUGH,		//[1]
		DRIVEWAY,		//[2]
		EMERGENCY__ACCESS,		//[3]
		PARKING__AISLE,		//[4]
		PROGRESS_POINT_CT,		//[5]
		PROGRESS_POINT_PARKWAY,		//[6]
		SIDING,		//[7]
		SPUR,		//[8]
		YARD,		//[9]
		LAST
	};
};

void initService(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Highway'
//*****************************************************************
struct Highway {
	enum {
		_NONE,		//[0] NONE
		BUS__STOP,		//[0]
		CONSTRUCTION,		//[1]
		CROSSING,		//[2]
		CYCLEWAY,		//[3]
		FOOTWAY,		//[4]
		LIVING__STREET,		//[5]
		MINI__ROUNDABOUT,		//[6]
		MOTORWAY,		//[7]
		MOTORWAY__JUNCTION,		//[8]
		MOTORWAY__LINK,		//[9]
		PATH,		//[10]
		PEDESTRIAN,		//[11]
		PRIMARY,		//[12]
		PRIMARY__LINK,		//[13]
		PROPOSED,		//[14]
		RACEWAY,		//[15]
		RESIDENTIAL,		//[16]
		RESIDENTIL,		//[17]
		ROAD,		//[18]
		SECONDARY,		//[19]
		SECONDARY__LINK,		//[20]
		SERVICE,		//[21]
		SIGN,		//[22]
		STEPS,		//[23]
		STOP,		//[24]
		TERTIARY,		//[25]
		TERTIARY__LINK,		//[26]
		TRACK,		//[27]
		TRAFFIC__SIGNALS,		//[28]
		TRUNK,		//[29]
		TRUNK__LINK,		//[30]
		TURNING__CIRCLE,		//[31]
		UNCLASSIFIED,		//[32]
		YIELD,		//[33]
		LAST
	};
};

void initHighway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Hgv'
//*****************************************************************
struct Hgv {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		NO,		//[1]
		YES,		//[2]
		LAST
	};
};

void initHgv(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Border__type'
//*****************************************************************
struct Border__type {
	enum {
		_NONE,		//[0] NONE
		CITY,		//[0]
		COUNTY,		//[1]
		NATIONAL,		//[2]
		STATE,		//[3]
		TOWN,		//[4]
		VILLAGE,		//[5]
		LAST
	};
};

void initBorder__type(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Man__made'
//*****************************************************************
struct Man__made {
	enum {
		_NONE,		//[0] NONE
		COMMUNICATIONS__TOWER,		//[0]
		DYKE,		//[1]
		FLAGPOLE,		//[2]
		MINE,		//[3]
		MONITORING__STATION,		//[4]
		PIER,		//[5]
		PIPELINE,		//[6]
		PUMPING__STATION,		//[7]
		RESERVOIR__COVERED,		//[8]
		TOWER,		//[9]
		WASTEWATER__PLANT,		//[10]
		WATER__TOWER,		//[11]
		YES,		//[12]
		LAST
	};
};

void initMan__made(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Proposed'
//*****************************************************************
struct Proposed {
	enum {
		_NONE,		//[0] NONE
		CYCLEWAY,		//[0]
		MOTORWAY,		//[1]
		RESIDENTIAL,		//[2]
		LAST
	};
};

void initProposed(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Information'
//*****************************************************************
struct Information {
	enum {
		_NONE,		//[0] NONE
		BOARD,		//[0]
		LAST
	};
};

void initInformation(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Boundary'
//*****************************************************************
struct Boundary {
	enum {
		_NONE,		//[0] NONE
		ADMINISTRATIVE,		//[0]
		PROTECTED__AREA,		//[1]
		LAST
	};
};

void initBoundary(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Cycleway'
//*****************************************************************
struct Cycleway {
	enum {
		_NONE,		//[0] NONE
		LANE,		//[0]
		NO,		//[1]
		SHARED,		//[2]
		LAST
	};
};

void initCycleway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Radar'
//*****************************************************************
struct Radar {
	enum {
		_NONE,		//[0] NONE
		NEXRAD,		//[0]
		LAST
	};
};

void initRadar(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Fishing'
//*****************************************************************
struct Fishing {
	enum {
		_NONE,		//[0] NONE
		PERMITTED,		//[0]
		LAST
	};
};

void initFishing(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Oneway'
//*****************************************************************
struct Oneway {
	enum {
		_NONE,		//[0] NONE
		_1,		//[0]
		D1,		//[1]
		NO,		//[2]
		REVERSIBLE,		//[3]
		YES,		//[4]
		LAST
	};
};

void initOneway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Nfd'
//*****************************************************************
struct Nfd {
	enum {
		_NONE,		//[0] NONE
		LAKE,		//[0]
		LAST
	};
};

void initNfd(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Cuisine'
//*****************************************************************
struct Cuisine {
	enum {
		_NONE,		//[0] NONE
		AMERICAN,		//[0]
		CHICKEN,		//[1]
		BAKERY,		//[2]
		BOSNIAN,		//[3]
		BURGER,		//[4]
		CAF__,		//[5]
		CHINESE,		//[6]
		COFFEE__SHOP,		//[7]
		DESSERTS,		//[8]
		DINER,		//[9]
		DONUT,		//[10]
		GREEK,		//[11]
		HAMBURGERS,		//[12]
		ICE_CREAM_AND_BURGERS,		//[13]
		ICE__CREAM,		//[14]
		ITALIAN,		//[15]
		ITALIAN_AMERICAN,		//[16]
		JAPANESE,		//[17]
		MEXICAN,		//[18]
		PANCAKE,		//[19]
		PIZZA,		//[20]
		ROAST_BEEF,		//[21]
		SANDWICH,		//[22]
		SMOOTHIES,		//[23]
		SOUTHERN,		//[24]
		SUBMARINES,		//[25]
		TEX_MEX,		//[26]
		LAST
	};
};

void initCuisine(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Artwork'
//*****************************************************************
struct Artwork {
	enum {
		_NONE,		//[0] NONE
		SCULPTURE,		//[0]
		LAST
	};
};

void initArtwork(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Golf'
//*****************************************************************
struct Golf {
	enum {
		_NONE,		//[0] NONE
		BUNKER,		//[0]
		FAIRWAY,		//[1]
		GREEN,		//[2]
		TEE,		//[3]
		LAST
	};
};

void initGolf(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Wifi'
//*****************************************************************
struct Wifi {
	enum {
		_NONE,		//[0] NONE
		FREE,		//[0]
		YES,		//[1]
		LAST
	};
};

void initWifi(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Bridge'
//*****************************************************************
struct Bridge {
	enum {
		_NONE,		//[0] NONE
		VIADUCT,		//[0]
		YES,		//[1]
		LAST
	};
};

void initBridge(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Office'
//*****************************************************************
struct Office {
	enum {
		_NONE,		//[0] NONE
		COMPANY,		//[0]
		LAST
	};
};

void initOffice(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Animal'
//*****************************************************************
struct Animal {
	enum {
		_NONE,		//[0] NONE
		FLAMINGOS,		//[0]
		PENGUINS,		//[1]
		PUFFINS,		//[2]
		LAST
	};
};

void initAnimal(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Product'
//*****************************************************************
struct Product {
	enum {
		_NONE,		//[0] NONE
		NATURAL__GAS,		//[0]
		LAST
	};
};

void initProduct(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Military'
//*****************************************************************
struct Military {
	enum {
		_NONE,		//[0] NONE
		AIRFIELD,		//[0]
		LAST
	};
};

void initMilitary(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Denotation'
//*****************************************************************
struct Denotation {
	enum {
		_NONE,		//[0] NONE
		NATURAL__MONUMENT,		//[0]
		LAST
	};
};

void initDenotation(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Aeroway'
//*****************************************************************
struct Aeroway {
	enum {
		_NONE,		//[0] NONE
		AERODROME,		//[0]
		APRON,		//[1]
		HELIPAD,		//[2]
		RUNWAY,		//[3]
		TAXIWAY,		//[4]
		TERMINAL,		//[5]
		LAST
	};
};

void initAeroway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Business'
//*****************************************************************
struct Business {
	enum {
		_NONE,		//[0] NONE
		PUBLIC_STORAGE,		//[0]
		SUBARU_DEALERSHIP,		//[1]
		VOLVO_DEALERSHIP,		//[2]
		LAST
	};
};

void initBusiness(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Denomination'
//*****************************************************************
struct Denomination {
	enum {
		_NONE,		//[0] NONE
		BAPTIST,		//[0]
		CATHOLIC,		//[1]
		EPISCOPAL,		//[2]
		JEHOVAHS__WITNESS,		//[3]
		LUTHERAN,		//[4]
		LUTHERAN_CHURCH____MISSOURI_SYNOD,		//[5]
		LUTHERAN_CHURCH___MISSOURI_SYNOD,		//[6]
		METHODIST,		//[7]
		MORMON,		//[8]
		NAZARENE,		//[9]
		ORTHODOX,		//[10]
		PENTECOSTAL,		//[11]
		PRESBYTERIAN,		//[12]
		ROMAN_CATHOLIC,		//[13]
		ROMAN__CATHOLIC,		//[14]
		SOTO__ZEN,		//[15]
		UNITED__CHURCH__OF__CHRIST,		//[16]
		LAST
	};
};

void initDenomination(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Natural'
//*****************************************************************
struct Natural {
	enum {
		_NONE,		//[0] NONE
		BEACH,		//[0]
		CLIFF,		//[1]
		LAND,		//[2]
		PEAK,		//[3]
		TREE,		//[4]
		WATER,		//[5]
		WETLAND,		//[6]
		WOOD,		//[7]
		LAST
	};
};

void initNatural(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Crossing'
//*****************************************************************
struct Crossing {
	enum {
		_NONE,		//[0] NONE
		TRAFFIC__SIGNALS,		//[0]
		LAST
	};
};

void initCrossing(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Monitoring__station'
//*****************************************************************
struct Monitoring__station {
	enum {
		_NONE,		//[0] NONE
		RADAR,		//[0]
		LAST
	};
};

void initMonitoring__station(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Parking'
//*****************************************************************
struct Parking {
	enum {
		_NONE,		//[0] NONE
		MULTI_STOREY,		//[0]
		MULTI_STORY,		//[1]
		SURFACE,		//[2]
		YES,		//[3]
		LAST
	};
};

void initParking(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Maxspeed'
//*****************************************************************
struct Maxspeed {
	enum {
		_NONE,		//[0] NONE
		D15_MPH,		//[0]
		D20,		//[1]
		D20_MPH,		//[2]
		D25_MPH,		//[3]
		D30,		//[4]
		D30_MPH,		//[5]
		D35_MMPH,		//[6]
		D35_MPH,		//[7]
		D40,		//[8]
		D40_MPH,		//[9]
		D45,		//[10]
		D45_MPH,		//[11]
		D55,		//[12]
		D55__MPH,		//[13]
		D55_MPH,		//[14]
		D60,		//[15]
		D60_MPH,		//[16]
		D65,		//[17]
		D65_MPH,		//[18]
		D70_MPH,		//[19]
		D75_MPH,		//[20]
		LAST
	};
};

void initMaxspeed(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Iata'
//*****************************************************************
struct Iata {
	enum {
		_NONE,		//[0] NONE
		ALN,		//[0]
		CPS,		//[1]
		STL,		//[2]
		LAST
	};
};

void initIata(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Modifier'
//*****************************************************************
struct Modifier {
	enum {
		_NONE,		//[0] NONE
		BUSINESS,		//[0]
		HISTORIC,		//[1]
		LAST
	};
};

void initModifier(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Land__use'
//*****************************************************************
struct Land__use {
	enum {
		_NONE,		//[0] NONE
		PLANT__NURSERY,		//[0]
		LAST
	};
};

void initLand__use(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Nat__name'
//*****************************************************************
struct Nat__name {
	enum {
		_NONE,		//[0] NONE
		PANERA_BREAD,		//[0]
		UNITED_STATES_ROUTE_67,		//[1]
		LAST
	};
};

void initNat__name(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Board__type'
//*****************************************************************
struct Board__type {
	enum {
		_NONE,		//[0] NONE
		MAP,		//[0]
		LAST
	};
};

void initBoard__type(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Industrial'
//*****************************************************************
struct Industrial {
	enum {
		_NONE,		//[0] NONE
		OIL,		//[0]
		LAST
	};
};

void initIndustrial(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Construction'
//*****************************************************************
struct Construction {
	enum {
		_NONE,		//[0] NONE
		MOTORWAY,		//[0]
		MOTORWAY__LINK,		//[1]
		PRIMARY,		//[2]
		RESIDENTIAL,		//[3]
		TERTIARY,		//[4]
		UNCLASSIFIED,		//[5]
		WIDENING,		//[6]
		LAST
	};
};

void initConstruction(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Route'
//*****************************************************************
struct Route {
	enum {
		_NONE,		//[0] NONE
		BICYCLE,		//[0]
		HIKING,		//[1]
		BOAT,		//[2]
		BUS,		//[3]
		FERRY,		//[4]
		LIGHT__RAIL,		//[5]
		RAILWAY,		//[6]
		ROAD,		//[7]
		TRAIN,		//[8]
		LAST
	};
};

void initRoute(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Attribution'
//*****************************************************************
struct Attribution {
	enum {
		_NONE,		//[0] NONE
		NHD,		//[0]
		USGS_2001_COUNTY_BOUNDARY,		//[1]
		LAST
	};
};

void initAttribution(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Site__type'
//*****************************************************************
struct Site__type {
	enum {
		_NONE,		//[0] NONE
		TUMULUS,		//[0]
		LAST
	};
};

void initSite__type(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Pcinecta'
//*****************************************************************
struct Pcinecta {
	enum {
		_NONE,		//[0] NONE
		N,		//[0]
		LAST
	};
};

void initPcinecta(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Building'
//*****************************************************************
struct Building {
	enum {
		_NONE,		//[0] NONE
		D5,		//[0]
		ABANDONED,		//[1]
		APARTMENTS,		//[2]
		CHURCH,		//[3]
		CIVIC,		//[4]
		COMMERCIAL,		//[5]
		ENTRANCE,		//[6]
		GAZEBO,		//[7]
		HANGAR,		//[8]
		HOUSE,		//[9]
		INDUSTRIAL,		//[10]
		MANUFACTURE,		//[11]
		OFFICE,		//[12]
		PUBLIC,		//[13]
		RAILWAY,		//[14]
		RESIDENTIAL,		//[15]
		RETAIL,		//[16]
		ROOF,		//[17]
		SCHOOL,		//[18]
		STADIUM,		//[19]
		SUPERMARKET,		//[20]
		TRAIN__STATION,		//[21]
		WAREHOUSE,		//[22]
		YES,		//[23]
		YMCA,		//[24]
		LAST
	};
};

void initBuilding(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Amenity'
//*****************************************************************
struct Amenity {
	enum {
		_NONE,		//[0] NONE
		AMEREN_UE,		//[0]
		ARTS__CENTRE,		//[1]
		ATM,		//[2]
		AUTOMOTIVE_OIL_CHANGE_STATION,		//[3]
		BANK,		//[4]
		BAR,		//[5]
		BENCH,		//[6]
		BICYCLE__PARKING,		//[7]
		BUS__STATION,		//[8]
		CAFE,		//[9]
		CAR__RENTAL,		//[10]
		CAR__WASH,		//[11]
		CASINO,		//[12]
		CINEMA,		//[13]
		CLINIC,		//[14]
		CLOCK,		//[15]
		COLLEGE,		//[16]
		COMMUNITY__CENTRE,		//[17]
		COURTHOUSE,		//[18]
		DENTIST,		//[19]
		DOCTORS,		//[20]
		DRINKING__WATER,		//[21]
		FAST__FOOD,		//[22]
		FIRE__STATION,		//[23]
		FOUNTAIN,		//[24]
		FUEL,		//[25]
		GOLF_COURSE,		//[26]
		GRAVE__YARD,		//[27]
		GYM,		//[28]
		HOSPITAL,		//[29]
		KINDERGARTEN,		//[30]
		LIBRARY,		//[31]
		MARKETPLACE,		//[32]
		NURSING__HOME,		//[33]
		PARK,		//[34]
		PARKING,		//[35]
		PHARMACY,		//[36]
		PICNIC__SHELTER,		//[37]
		PLACE__OF__WORSHIP,		//[38]
		POLICE,		//[39]
		POST__BOX,		//[40]
		POST__OFFICE,		//[41]
		PRISON,		//[42]
		PUB,		//[43]
		PUBLIC__BUILDING,		//[44]
		RECYCLING,		//[45]
		RESTAURANT,		//[46]
		ROBERT_A_YOUNG_FEDERAL_BUILDING,		//[47]
		SAINT_LOUIS_CITY_CIVIL_COURTS,		//[48]
		SAINT_LOUIS_CITY_JUSTICE_CENTER__JAIL_P_,		//[49]
		SAINT_LOUIS_CITY_MORGUE,		//[50]
		SCHOOL,		//[51]
		SEWER,		//[52]
		SHELTER,		//[53]
		SWIMMING__POOL,		//[54]
		TELEPHONE,		//[55]
		THEATRE,		//[56]
		TOILETS,		//[57]
		TOWNHALL,		//[58]
		UNIVERSITY,		//[59]
		VETERINARY,		//[60]
		WATER__TANK,		//[61]
		LAST
	};
};

void initAmenity(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Sac__scale'
//*****************************************************************
struct Sac__scale {
	enum {
		_NONE,		//[0] NONE
		HIKING,		//[0]
		LAST
	};
};

void initSac__scale(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Highway2'
//*****************************************************************
struct Highway2 {
	enum {
		_NONE,		//[0] NONE
		RESIDENTIAL,		//[0]
		LAST
	};
};

void initHighway2(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Local__ref'
//*****************************************************************
struct Local__ref {
	enum {
		_NONE,		//[0] NONE
		LOCAL__KNOWLEDGE,		//[0]
		LAST
	};
};

void initLocal__ref(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Fee'
//*****************************************************************
struct Fee {
	enum {
		_NONE,		//[0] NONE
		D0,		//[0]
		NO,		//[1]
		YES,		//[2]
		LAST
	};
};

void initFee(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Sidewalk'
//*****************************************************************
struct Sidewalk {
	enum {
		_NONE,		//[0] NONE
		BOTH,		//[0]
		NONE,		//[1]
		RIGHT,		//[2]
		LAST
	};
};

void initSidewalk(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Leisure'
//*****************************************************************
struct Leisure {
	enum {
		_NONE,		//[0] NONE
		WATER__PARK,		//[0]
		ARENA,		//[1]
		BLEACHERS,		//[2]
		DOG__PARK,		//[3]
		FITNESS__CENTRE,		//[4]
		GARDEN,		//[5]
		GOLF__COURSE,		//[6]
		ICE__RINK,		//[7]
		NATURE__RESERVE,		//[8]
		PARK,		//[9]
		PITCH,		//[10]
		PLAYGROUND,		//[11]
		PLAYGROUND_,		//[12]
		RECREATION__GROUND,		//[13]
		SKATEPARK,		//[14]
		SLIPWAY,		//[15]
		SPORTS__CENTRE,		//[16]
		STADIUM,		//[17]
		SWIMMING__POOL,		//[18]
		TRACK,		//[19]
		LAST
	};
};

void initLeisure(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Historic'
//*****************************************************************
struct Historic {
	enum {
		_NONE,		//[0] NONE
		ARCHAEOLOGICAL__SITE,		//[0]
		BUILDING,		//[1]
		MEMORIAL,		//[2]
		MONUMENT,		//[3]
		SCHOOL,		//[4]
		STATUE,		//[5]
		YES,		//[6]
		LAST
	};
};

void initHistoric(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Destination'
//*****************************************************************
struct Destination {
	enum {
		_NONE,		//[0] NONE
		GULF_OF_MEXICO,		//[0]
		MISSISSIPPI_RIVER,		//[1]
		LAST
	};
};

void initDestination(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Boat'
//*****************************************************************
struct Boat {
	enum {
		_NONE,		//[0] NONE
		NO,		//[0]
		PRIVATE,		//[1]
		YES,		//[2]
		LAST
	};
};

void initBoat(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Attraction'
//*****************************************************************
struct Attraction {
	enum {
		_NONE,		//[0] NONE
		ANIMAL,		//[0]
		ANTIQUE__CARS,		//[1]
		BIG__WHEEL,		//[2]
		CAROUSEL,		//[3]
		LOG__FLUME,		//[4]
		RAPIDS,		//[5]
		ROLLER__COASTER,		//[6]
		SCRAMBLER,		//[7]
		SHOOT__THE__CHUTES,		//[8]
		LAST
	};
};

void initAttraction(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'State'
//*****************************************************************
struct State {
	enum {
		_NONE,		//[0] NONE
		ALTERNATE,		//[0]
		PROPOSED,		//[1]
		TEMPORARY,		//[2]
		LAST
	};
};

void initState(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Power'
//*****************************************************************
struct Power {
	enum {
		_NONE,		//[0] NONE
		BUSBAR,		//[0]
		GENERATOR,		//[1]
		LINE,		//[2]
		POLE,		//[3]
		PORTAL,		//[4]
		STATION,		//[5]
		SUB__STATION,		//[6]
		SWITCH,		//[7]
		TAP,		//[8]
		TOWER,		//[9]
		TRANSFORMER,		//[10]
		LAST
	};
};

void initPower(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Barrier'
//*****************************************************************
struct Barrier {
	enum {
		_NONE,		//[0] NONE
		BLOCK,		//[0]
		BOLLARD,		//[1]
		CITY__WALL,		//[2]
		CRASH__RAIL,		//[3]
		CYCLE__BARRIER,		//[4]
		FENCE,		//[5]
		GATE,		//[6]
		HEDGE,		//[7]
		LIFT__GATE,		//[8]
		MEDIAN,		//[9]
		PARK_DONATION_COLLECTION_BOX,		//[10]
		RETAINING__WALL,		//[11]
		WALL,		//[12]
		WIRE__FENCE,		//[13]
		LAST
	};
};

void initBarrier(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Emergency'
//*****************************************************************
struct Emergency {
	enum {
		_NONE,		//[0] NONE
		FIRE__HYDRANT,		//[0]
		NO,		//[1]
		YES,		//[2]
		LAST
	};
};

void initEmergency(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Funcstat'
//*****************************************************************
struct Funcstat {
	enum {
		_NONE,		//[0] NONE
		A,		//[0]
		S,		//[1]
		LAST
	};
};

void initFuncstat(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Electrified'
//*****************************************************************
struct Electrified {
	enum {
		_NONE,		//[0] NONE
		D165,		//[0]
		CONTACT__LINE,		//[1]
		NO,		//[2]
		LAST
	};
};

void initElectrified(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Golf__cart'
//*****************************************************************
struct Golf__cart {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		LAST
	};
};

void initGolf__cart(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Pcicbsa'
//*****************************************************************
struct Pcicbsa {
	enum {
		_NONE,		//[0] NONE
		N,		//[0]
		Y,		//[1]
		LAST
	};
};

void initPcicbsa(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Type'
//*****************************************************************
struct Type {
	enum {
		_NONE,		//[0] NONE
		ASSOCIATEDSTREET,		//[0]
		BOUNDARY,		//[1]
		BROAD__LEAFED,		//[2]
		HIGHSCHOOL,		//[3]
		MULTIPOLYGON,		//[4]
		PUBLIC,		//[5]
		RAILWAY,		//[6]
		RANGE,		//[7]
		RESTRICTION,		//[8]
		ROUTE,		//[9]
		ROUTE__MASTER,		//[10]
		WATERWAY,		//[11]
		LAST
	};
};

void initType(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Bicycle'
//*****************************************************************
struct Bicycle {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		NO,		//[1]
		PRIVATE,		//[2]
		YES,		//[3]
		LAST
	};
};

void initBicycle(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Waterway'
//*****************************************************************
struct Waterway {
	enum {
		_NONE,		//[0] NONE
		CANAL,		//[0]
		DAM,		//[1]
		DOCK,		//[2]
		DRAIN,		//[3]
		LAKE,		//[4]
		LOCK__GATE,		//[5]
		RIVER,		//[6]
		RIVERBANK,		//[7]
		SPRING,		//[8]
		STREAM,		//[9]
		WEIR,		//[10]
		LAST
	};
};

void initWaterway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Maxstay'
//*****************************************************************
struct Maxstay {
	enum {
		_NONE,		//[0] NONE
		BALL_GAME_DURATION,		//[0]
		GAME_DURRATION,		//[1]
		LAST
	};
};

void initMaxstay(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Tourism'
//*****************************************************************
struct Tourism {
	enum {
		_NONE,		//[0] NONE
		ARTWORK,		//[0]
		ATTRACTION,		//[1]
		CARAVAN__SITE,		//[2]
		HOTEL,		//[3]
		INFORMATION,		//[4]
		MOTEL,		//[5]
		MUSEUM,		//[6]
		PICNIC__SITE,		//[7]
		THEME__PARK,		//[8]
		VIEWPOINT,		//[9]
		ZOO,		//[10]
		LAST
	};
};

void initTourism(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Shelter__type'
//*****************************************************************
struct Shelter__type {
	enum {
		_NONE,		//[0] NONE
		PICNIC__SHELTER,		//[0]
		LAST
	};
};

void initShelter__type(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Tower'
//*****************************************************************
struct Tower {
	enum {
		_NONE,		//[0] NONE
		COMMUNICATION,		//[0]
		LAST
	};
};

void initTower(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Sym'
//*****************************************************************
struct Sym {
	enum {
		_NONE,		//[0] NONE
		LODGING,		//[0]
		LAST
	};
};

void initSym(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Religion'
//*****************************************************************
struct Religion {
	enum {
		_NONE,		//[0] NONE
		BUDDHIST,		//[0]
		CHRISTIAN,		//[1]
		JEWISH,		//[2]
		MUSLIM,		//[3]
		LAST
	};
};

void initReligion(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Faa'
//*****************************************************************
struct Faa {
	enum {
		_NONE,		//[0] NONE
		ALN,		//[0]
		CPS,		//[1]
		LAST
	};
};

void initFaa(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Railway'
//*****************************************************************
struct Railway {
	enum {
		_NONE,		//[0] NONE
		ABANDONED,		//[0]
		BUFFER__STOP,		//[1]
		DISUSED,		//[2]
		LEVEL__CROSSING,		//[3]
		LIGHT__RAIL,		//[4]
		NARROW__GAUGE,		//[5]
		PLATFORM,		//[6]
		RAIL,		//[7]
		RAILWAY__CROSSING,		//[8]
		STATION,		//[9]
		SWITCH,		//[10]
		LAST
	};
};

void initRailway(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Junction'
//*****************************************************************
struct Junction {
	enum {
		_NONE,		//[0] NONE
		ROUNDABOUT,		//[0]
		SPUI,		//[1]
		LAST
	};
};

void initJunction(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Generator'
//*****************************************************************
struct Generator {
	enum {
		_NONE,		//[0] NONE
		D800_MW,		//[0]
		D923_MW,		//[1]
		COAL,		//[2]
		COMBUSTION,		//[3]
		LAST
	};
};

void initGenerator(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Place'
//*****************************************************************
struct Place {
	enum {
		_NONE,		//[0] NONE
		CITY,		//[0]
		COUNTY,		//[1]
		HAMLET,		//[2]
		ISLAND,		//[3]
		ISLET,		//[4]
		LOCALITY,		//[5]
		PLACE__OF__WORSHIP,		//[6]
		ST__LOUIS,		//[7]
		TOWN,		//[8]
		VILLAGE,		//[9]
		LAST
	};
};

void initPlace(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Shop'
//*****************************************************************
struct Shop {
	enum {
		_NONE,		//[0] NONE
		GAMING,		//[0]
		VIDEO,		//[1]
		__CRAFTS,		//[2]
		ARTS___AMP,		//[3]
		BAKERY,		//[4]
		BEAUTY,		//[5]
		BEVERAGES,		//[6]
		BICYCLE,		//[7]
		BOOKS,		//[8]
		CAR,		//[9]
		CAR__REPAIR,		//[10]
		CAR__WASH,		//[11]
		CLOTHES,		//[12]
		COMMUNICATIONS,		//[13]
		CONVENIENCE,		//[14]
		DECORATIVE,		//[15]
		DEPARTMENT__STORE,		//[16]
		DOITYOURSELF,		//[17]
		DRY__CLEANING,		//[18]
		ELECTRONICS,		//[19]
		FABRIC,		//[20]
		GARDEN__CENTRE,		//[21]
		GIFT,		//[22]
		GREENGROCER,		//[23]
		HAIRDRESSER,		//[24]
		HARDWARE,		//[25]
		HOME_FURNISHINGS,		//[26]
		JEFFERSON_BARRACKS_PARK_SOUTH_TRAILHEAD,		//[27]
		MALL,		//[28]
		MOTORCYCLE,		//[29]
		MUSIC,		//[30]
		OFFICE__SERVICES,		//[31]
		OPTICIAN,		//[32]
		PARTY,		//[33]
		PET,		//[34]
		SHOES,		//[35]
		SPORTS,		//[36]
		STATIONERY,		//[37]
		SUPERMARKET,		//[38]
		TANNING,		//[39]
		TOYS,		//[40]
		VARIETY,		//[41]
		LAST
	};
};

void initShop(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Species'
//*****************************************************************
struct Species {
	enum {
		_NONE,		//[0] NONE
		AESCULUS_PAVIA,		//[0]
		RED_BUCKEYE,		//[1]
		LAST
	};
};

void initSpecies(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Psv'
//*****************************************************************
struct Psv {
	enum {
		_NONE,		//[0] NONE
		OFFICIAL,		//[0]
		YES,		//[1]
		LAST
	};
};

void initPsv(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Surface'
//*****************************************************************
struct Surface {
	enum {
		_NONE,		//[0] NONE
		ASPHALT,		//[0]
		CLAY,		//[1]
		CONCRETE,		//[2]
		DIRT,		//[3]
		GRASS,		//[4]
		GRAVEL,		//[5]
		LIMESTONE,		//[6]
		PAVED,		//[7]
		PEBBLESTONE,		//[8]
		ROCKY,		//[9]
		SAND,		//[10]
		UNPAVED,		//[11]
		WOOD,		//[12]
		LAST
	};
};

void initSurface(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Odbl'
//*****************************************************************
struct Odbl {
	enum {
		_NONE,		//[0] NONE
		CLEAN,		//[0]
		LAST
	};
};

void initOdbl(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Motorcar'
//*****************************************************************
struct Motorcar {
	enum {
		_NONE,		//[0] NONE
		NO,		//[0]
		PRIVATE,		//[1]
		YES,		//[2]
		LAST
	};
};

void initMotorcar(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Highwy'
//*****************************************************************
struct Highwy {
	enum {
		_NONE,		//[0] NONE
		TURNING__CIRCLE,		//[0]
		LAST
	};
};

void initHighwy(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Name__base__4'
//*****************************************************************
struct Name__base__4 {
	enum {
		_NONE,		//[0] NONE
		COUNTY_HIGHWAY_16,		//[0]
		COUNTY_ROAD_27,		//[1]
		LAST
	};
};

void initName__base__4(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Landuse'
//*****************************************************************
struct Landuse {
	enum {
		_NONE,		//[0] NONE
		BASIN,		//[0]
		BROWNFIELD,		//[1]
		CEMETERY,		//[2]
		COMMERCIAL,		//[3]
		CONSTRUCTION,		//[4]
		FARM,		//[5]
		FARMLAND,		//[6]
		FOREST,		//[7]
		GRASS,		//[8]
		INDUSTRIAL,		//[9]
		LANDFILL,		//[10]
		MILITARY,		//[11]
		POND,		//[12]
		QUARRY,		//[13]
		RECREATION__GROUND,		//[14]
		RESERVOIR,		//[15]
		RESIDENTIAL,		//[16]
		RETAIL,		//[17]
		WASTE__WATER__PLANT,		//[18]
		LAST
	};
};

void initLanduse(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Motor__vehicle'
//*****************************************************************
struct Motor__vehicle {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		NO,		//[1]
		PRIVATE,		//[2]
		YES,		//[3]
		LAST
	};
};

void initMotor__vehicle(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Timezone'
//*****************************************************************
struct Timezone {
	enum {
		_NONE,		//[0] NONE
		AMERICA_CHICAGO,		//[0]
		LAST
	};
};

void initTimezone(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Name2'
//*****************************************************************
struct Name2 {
	enum {
		_NONE,		//[0] NONE
		FRITCH_PL,		//[0]
		MELBA_PL,		//[1]
		LAST
	};
};

void initName2(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Access'
//*****************************************************************
struct Access {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		NO,		//[1]
		PERMISSIVE,		//[2]
		PRIVATE,		//[3]
		YES,		//[4]
		LAST
	};
};

void initAccess(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Tunnel'
//*****************************************************************
struct Tunnel {
	enum {
		_NONE,		//[0] NONE
		FILLED,		//[0]
		YES,		//[1]
		LAST
	};
};

void initTunnel(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Foot'
//*****************************************************************
struct Foot {
	enum {
		_NONE,		//[0] NONE
		DESIGNATED,		//[0]
		NO,		//[1]
		YES,		//[2]
		LAST
	};
};

void initFoot(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Trail__visibility'
//*****************************************************************
struct Trail__visibility {
	enum {
		_NONE,		//[0] NONE
		EXCELLENT,		//[0]
		LAST
	};
};

void initTrail__visibility(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Sport'
//*****************************************************************
struct Sport {
	enum {
		_NONE,		//[0] NONE
		SOCCER,		//[0]
		AMERICAN__FOOTBALL,		//[1]
		FOOTBALL,		//[2]
		ARCHERY,		//[3]
		ATHLETICS,		//[4]
		BASEBALL,		//[5]
		BASKETBALL,		//[6]
		BEACHVOLLEYBALL,		//[7]
		GOLF,		//[8]
		GYMNASTICS,		//[9]
		HANDBALL,		//[10]
		HOCKEY,		//[11]
		HORSE__RACING,		//[12]
		LACROSSE,		//[13]
		RACQUET,		//[14]
		RUNNING,		//[15]
		SHOOTING,		//[16]
		SWIMMING,		//[17]
		TENNIS,		//[18]
		VOLLEYBALL,		//[19]
		LAST
	};
};

void initSport(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'Restriction'
//*****************************************************************
struct Restriction {
	enum {
		_NONE,		//[0] NONE
		NO__LEFT__TURN,		//[0]
		NO__U__TURN,		//[1]
		ONLY__LEFT__TURN,		//[2]
		ONLY__RIGHT__TURN,		//[3]
		ONLY__STRAIGHT__ON,		//[4]
		LAST
	};
};

void initRestriction(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'DirectionType'
//*****************************************************************
struct DirectionType {
	enum {
		_NONE,		//[0] NONE
		N,		//[0]
		W,		//[1]
		E,		//[2]
		S,		//[3]
		NE,		//[4]
		SE,		//[5]
		EAST,		//[6]
		N_S,		//[7]
		NORTH,		//[8]
		NW,		//[9]
		O,		//[10]
		SOUTH,		//[11]
		SW,		//[12]
		WEST,		//[13]
		LAST
	};
};

void initDirectionType(StringTableInt &types);
//*****************************************************************


//*****************************************************************
// Enumeration Definition for 'NameType'
//*****************************************************************
struct NameType {
	enum {
		_NONE,		//[0] NONE
		AVE,		//[0]
		CT,		//[1]
		DR,		//[2]
		RD,		//[3]
		ST,		//[4]
		BLVD,		//[5]
		LN,		//[6]
		CIR,		//[7]
		HWY,		//[8]
		PKY,		//[9]
		PL,		//[10]
		TRL,		//[11]
		WAY,		//[12]
		ALY,		//[13]
		BR,		//[14]
		BRG,		//[15]
		CTR,		//[16]
		CV,		//[17]
		EXPY,		//[18]
		PASS,		//[19]
		PLZ,		//[20]
		RAMP,		//[21]
		RUN,		//[22]
		SPUR,		//[23]
		SQ,		//[24]
		TER,		//[25]
		TPKE,		//[26]
		WALK,		//[27]
		XING,		//[28]
		ARC,		//[29]
		BOULEVARD,		//[30]
		BRG_ST,		//[31]
		BRIDGE,		//[32]
		DR_LN,		//[33]
		DR_RD,		//[34]
		DRIVE,		//[35]
		LOOP,		//[36]
		MAL,		//[37]
		OVPS,		//[38]
		PATH,		//[39]
		PKWY,		//[40]
		ROW,		//[41]
		RTE,		//[42]
		TRAIL,		//[43]
		TRCE,		//[44]
		LAST
	};
};

void initNameType(StringTableInt &types);
//*****************************************************************



extern TagType gWayTagTypes[WTT_LAST];

void initTagEnums(void);

gpstxt::GtU32 getTagEnum(WayTagType type,const char *str);
gpstxt::GtU32 getTagCount(WayTagType type);



}; // End of gpstxt namespace.
#endif
